/**
  1.方法def声明，可以为private proteted控制权限。不写时默认是public
  2.自动推断类型时，必须加入等号才能返回。不然返回值是空类型（Unit）
    注意：定义递归方法，不能省略返回值类型
  3.def 方法名(形参名:类型, 形参名:类型= 默认值) = {方法体}
     注意：只有一行可以省略{}
  4.def 方法名(形参名:类型 *) = {方法体}
           可变参数：本质可以看成数组
  5.函数
    val 函数变量名 = (参数名:参数类型, 参数名:参数类型....) => 函数体
      注意：最多支持22个参数
  6. 成员函数：定义在类中的方法
               本地函数：内嵌在函数内的函数
               匿名函数：没有函数名，且使用连接符=> 如：(a:Int,b:Int)=>{a+b}
                                   可以作为参数传递
               高阶函数：函数当成参数传递,属于函数式编程。
  7.匿名函数简化规则:
                参数类型可以推断，那么可以省略类型
                只有一个参数，那么可以省略()
                通过_代替参数

 8方法和函数的区别
   （1）方法是隶属于类或者对象的，在运行时，它是加载到JVM的方法区中
   （2）可以将函数对象赋值给一个变量，在运行时，它是加载到JVM的堆内存中
   （3）函数是一个对象，继承自FunctionN，函数对象有apply，curried，toString，tupled这些方法，而方法则没有
 9.方法转函数：使用_
     val a = add _
 10.柯里化本质：第一个()转换成一个函数，后面的（）都是函数调用

 11.闭包：函数里面引用外面类成员变量叫作闭包
 */

  println("Welcome to the Scala worksheet")
	  //--------方法定义--------------
	 def f1():String={
	    "hello"
	 }
	 def f2():Array[Int]={
	   Array(1,2,3)
	 }
	 //-----------不明确返回值类型：自动推断为array------------
	 def f3()={
	   Array(1,2,3)
	 }
	 //-----------不明确返回值类型，如果没等号，那么返回类型为空类型（Unit）------------
	 def f4(){
	   Array(1,2,3)
	 }
	 //含参数
	 def f5(a:Int,b:Int) = {
	   a +b
	 }
	 f5(1,3)
	 //默认值
	 def f6(a:Int,b:String ="a") = {
	    a+b
	 }
	 f6(3)
	 //匿名函数赋值给一个常量
	 val f7 = (a:Int,b:Int)=>{a + b}
	 f7(1,5)
	 def f8(a:Int,b:Int,f:(Int,Int)=>Int) = {
	    f(a +2,b)
	 }
	 f8(1,2,f7 )
	 f8(1,2,(a:Int,b:Int)=>{a + b} )
	 //简化
	 f8(1,2,(a,b)=> a + b )
	 f8(1,2,_+_ )
	 //底层支持柯里化技术，所以可以这么写:多个参数转换成单个参数
	 def f9(a:Int)(b:Int)={a+b}
	 f9(1)(2)
	 
	 def f81(a:Int,b:Int)(f:(Int,Int)=>Int) = {
	    f(a +2,b)
	 }
	 f81(1,2)(f7)

 //下面这些操作就是使用到了柯里化
	List(1,2,3,4).fold(0)(_+_)
	List(1,2,3,4).foldLeft(0)(_+_)
	List(1,2,3,4).foldRight(0)(_+_)
 //-----闭包：函数里面引用外面类成员变量叫作闭包---
	var factor=10
	val f1=(x:Int) => x*factor
